import java.util.*;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: DELL
 * Date: 2022-10-19
 * Time: 14:50
 */

/**
 * Map的使用
 */
public class Test_Map {
    public static void main2(String[] args) {
        TreeMap<String,Integer> map = new TreeMap<>();
        // TreeMaap中，key值不为空且唯一 value可以重复
        //map.put(null,1);

    }

    /**
     * TreeMap 的常用方法使用
     * @param args
     */

    public static void main1(String[] args) {
        TreeMap<String,Integer> map = new TreeMap<>();
        map.put("zhangfei",3); // 插入 值为 key-value的键值对
        map.put("zhangfei",4); // 重复添加替代之前key所对应的value


        /*System.out.println(map.get("zhangfei")); // 返回key所对应的value值
        System.out.println(map.get("lisi")); // 不存在则返回类型的空

        // 返回key对应的value值，若不存在返回所设置的默认defaultValue值
        System.out.println(map.getOrDefault("lisi", 2));

        // 删除key对应的映射关系  key 和 value 在map中均不在存在
        //System.out.println(map.remove("zhangfei")); // key映射的value值
        System.out.println(map.get("zhangfei")); // 返回null 因为不存在Sting类型的“zhangfei”

        System.out.println(map.containsKey("zhangfei"));
        System.out.println(map.containsKey("lisi"));
        System.out.println(map.containsValue(4));
        System.out.println(map.containsValue(5));

        Set<Integer> set =new TreeSet<>();*/

    }

    /**
     * HashMap的使用
     * @param args
     */
    public static void main3(String[] args) {
        HashMap<String,Integer>map = new HashMap<>();
        map.put("zhangfei",1);
        System.out.println(map.get("zhangfei"));
        System.out.println(map.get("lisi"));
    }

    static class Node{
        public int val;
        public Node next;
        public Node random;

        public Node(int val) {
            this.val = val;
            this.next = null;
            this.random = null;
        }
    }
    public Node head;

    public Node copyRandomList(Node head) {
        HashMap<Node,Node> map = new HashMap<>();
        Node cur = head;
        // 遍历链表，将老节点得地址和复制后新节点得地址存起来
        while(cur != null) {
            Node node = new Node(cur.val);
            // 将老节点和新节点对应关系存储
            map.put(cur,node);
            cur = cur.next;
        }
        cur = head;
        // 再次遍历链表，取出对应关系
        while(cur != null) {
            // 老节点地址得节点    下一个节点得新地址
            map.get(cur).next = map.get(cur.next);
            // 老节点地址得随机节点
            map.get(cur).random = map.get(cur.random);
            cur = cur.next;
        }
        // 返回老系欸但得头对应得新节点得头
        return map.get(head);
    }

    /**
     * 数组中最小得K个数
     * @param arr
     * @param k
     * @return
     */
        public int[] smallestK(int[] arr, int k) {
            int[] vec = new int[k];
            if (k == 0) { // 排除 0 的情况
                return vec;
            }
            PriorityQueue<Integer> queue = new PriorityQueue<Integer>(new Comparator<Integer>() {
                public int compare(Integer num1, Integer num2) {
                    return num2 - num1;
                }
            });
            for (int i = 0; i < k; ++i) {
                queue.offer(arr[i]);
            }
            for (int i = k; i < arr.length; ++i) {
                if (queue.peek() > arr[i]) {
                    queue.poll();
                    queue.offer(arr[i]);
                }
            }
            for (int i = 0; i < k; ++i) {
                vec[i] = queue.poll();
            }
            return vec;

        }

    public void main(String[] args) {

    }
}
